package 炫彩元素类

import (
	xc "gitee.com/go_888/xcgui/xcgui/xc"
	xcc "gitee.com/go_888/xcgui/xcgui/xcc"
)

// X结构_列表视图 列表视图.
type X结构_列表视图 struct {
	X结构_滚动视图
}

// 列表视_创建.
//
// x: 元素x坐标.
//
// y: 元素y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// hParent: 父是窗口资源句柄或UI元素资源句柄. 如果是窗口资源句柄将被添加到窗口, 如果是元素资源句柄将被添加到元素.
func X创建列表视图(元素x坐标, 元素y坐标, 宽度, 高度 int32, 父窗口句柄 int) *X结构_列表视图 {
	p := &X结构_列表视图{}
	p.X设置句柄(xc.X列表视图_创建(元素x坐标, 元素y坐标, 宽度, 高度, 父窗口句柄))
	return p
}

// 列表视_创建Ex. 创建列表视图元素, 使用内置项模板, 自动创建数据适配器.
//
// x: 元素x坐标.
//
// y: 元素y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// hParent: 父是窗口资源句柄或UI元素资源句柄. 如果是窗口资源句柄将被添加到窗口, 如果是元素资源句柄将被添加到元素.
//
// col_extend_count: 列数量. 例如: 内置模板是1列, 如果数据有5列, 那么此参数填5.
func X创建列表视图Ex(元素x坐标, 元素y坐标, 宽度, 高度 int32, 父窗口句柄, 列数量 int32) *X结构_列表视图 {
	p := &X结构_列表视图{}
	p.X设置句柄(xc.X列表视图_创建Ex(元素x坐标, 元素y坐标, 宽度, 高度, 父窗口句柄, 列数量))
	return p
}

// 从句柄创建对象.
func X创建列表视图并按句柄(句柄 int) *X结构_列表视图 {
	p := &X结构_列表视图{}
	p.X设置句柄(句柄)
	return p
}

// 从name创建对象, 失败返回nil.
func X创建列表视图并按名称(名称 string) *X结构_列表视图 {
	handle := xc.X取对象并按名称(名称)
	if handle > 0 {
		p := &X结构_列表视图{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID创建对象, 失败返回nil.
func X创建列表视图并按UID(UID int32) *X结构_列表视图 {
	handle := xc.X取对象并按UID(UID)
	if handle > 0 {
		p := &X结构_列表视图{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID名称创建对象, 失败返回nil.
func X创建列表视图并按UID名称(名称 string) *X结构_列表视图 {
	handle := xc.X取对象并按UID名称(名称)
	if handle > 0 {
		p := &X结构_列表视图{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 列表视_创建数据适配器, 创建数据适配器，根据绑定的项模板初始化数据适配器的列, 返回适配器句柄.
func (l *X结构_列表视图) X创建数据适配器() int {
	return xc.X列表视图_创建数据适配器(l.X句柄)
}

// 列表视_绑定数据适配器.
//
// hAdapter: 数据适配器XAdListView.
func (l *X结构_列表视图) X绑定数据适配器(数据适配器 int) *X结构_列表视图 {
	xc.X列表视图_绑定数据适配器(l.X句柄, 数据适配器)
	return l
}

// 列表视_取数据适配器, 返回数据适配器句柄.
func (l *X结构_列表视图) X取数据适配器() int {
	return xc.X列表视图_取数据适配器(l.X句柄)
}

// 列表视_置项模板文件.
//
// pXmlFile: 文件名.
func (l *X结构_列表视图) X设置项模板文件(文件名 string) bool {
	return xc.X列表视图_设置项模板文件(l.X句柄, 文件名)
}

// 列表视_置项模板从字符串.
//
// pStringXML: 字符串.
func (l *X结构_列表视图) X设置项模板从文本(xml文本 string) bool {
	return xc.X列表视图_设置项模板从文本(l.X句柄, xml文本)
}

// 列表视_置项模板, 置列表项模板.
//
// hTemp: 模板句柄.
func (l *X结构_列表视图) X设置项模板(模板句柄 int) bool {
	return xc.X列表视图_设置项模板(l.X句柄, 模板句柄)
}

// 列表视_取模板对象, 通过模板项ID, 获取实例化模板项ID对应的对象句柄.
//
// iGroup: 组索引.
//
// iItem: 项索引.
//
// nTempItemID: 模板项ID.
func (l *X结构_列表视图) X取模板对象(组索引 int32, 项索引 int32, 模板项ID int32) int {
	return xc.X列表视图_取模板对象(l.X句柄, 组索引, 项索引, 模板项ID)
}

// 列表视_取模板对象组, 通过模板项ID, 获取实例化模板项ID对应的对象句柄.
//
// iGroup: 组索引.
//
// nTempItemID: 模板项ID.
func (l *X结构_列表视图) X取模板对象组(组索引 int32, 模板项ID int32) int {
	return xc.X列表视图_取模板对象组(l.X句柄, 组索引, 模板项ID)
}

// 列表视_取对象所在项, 获取当前对象所在模板实例, 属于列表视中哪一个项.
//
// hXCGUI: 对象句柄, UI元素句柄或形状对象句柄.
//
// piGroup: 接收组索引.
//
// piItem: 接收项索引.
func (l *X结构_列表视图) X取对象所在项(对象句柄 int, 返回组索引 *int32, 返回项索引 *int32) bool {
	return xc.X列表视图_取对象所在项(l.X句柄, 对象句柄, 返回组索引, 返回项索引)
}

// 列表视_测试点击项, 检查坐标点所在项.
//
// pPt: 坐标点.
//
// pOutGroup: 接收组索引.
//
// pOutItem: 接收项索引.
func (l *X结构_列表视图) X测试点击项(坐标点 *xc.X结构_坐标, 返回组索引 *int32, 返回项索引 *int32) bool {
	return xc.X列表视图_测试点击项(l.X句柄, 坐标点, 返回组索引, 返回项索引)
}

// 列表视_测试点击项扩展, 检查坐标点所在项, 自动添加滚动视图偏移量.
//
// pPt: 坐标点.
//
// pOutGroup: 接收做索引.
//
// pOutItem: 接收项索引.
func (l *X结构_列表视图) X测试点击项EX(坐标点 *xc.X结构_坐标, 返回组索引 *int32, 返回项索引 *int32) bool {
	return xc.X列表视图_测试点击项EX(l.X句柄, 坐标点, 返回组索引, 返回项索引)
}

// 列表视_启用多选.
//
// bEnable: 是否启用.
func (l *X结构_列表视图) X启用多选(是否启用 bool) *X结构_列表视图 {
	xc.X列表视图_启用多选(l.X句柄, 是否启用)
	return l
}

// 列表视_启用模板复用.
//
// bEnable: 是否启用.
func (l *X结构_列表视图) X启用模板复用(是否启用 bool) *X结构_列表视图 {
	xc.X列表视图_启用模板复用(l.X句柄, 是否启用)
	return l
}

// 列表视_启用虚表.
//
// bEnable: 是否启用.
func (l *X结构_列表视图) X启用虚表(是否启用 bool) *X结构_列表视图 {
	xc.X列表视图_启用虚表(l.X句柄, 是否启用)
	return l
}

// 列表视_置虚表项数量.
//
// iGroup: 组索引.
//
// nCount: 项数量.
func (l *X结构_列表视图) X设置虚表项数量(组索引 int32, 项数量 int32) bool {
	return xc.X列表视图_设置虚表项数量(l.X句柄, 组索引, 项数量)
}

// 列表视_置项背景绘制标志, 置是否绘制指定状态下项的背景.
//
// nFlags: 标志位: List_DrawItemBk_Flag_.
func (l *X结构_列表视图) X设置项背景绘制标志(标志位 xcc.X项背景绘制标识) *X结构_列表视图 {
	xc.X列表视图_设置项背景绘制标志(l.X句柄, 标志位)
	return l
}

// 列表视_置选择项.
//
// iGroup: 组索引.
//
// iItem: 项索引.
func (l *X结构_列表视图) X设置选择项(组索引 int32, 项索引 int32) bool {
	return xc.X列表视图_设置选择项(l.X句柄, 组索引, 项索引)
}

// 列表视_取选择项.
//
// piGroup: 接收组索引.
//
// piItem: 接收项索引.
func (l *X结构_列表视图) X取选择项(返回组索引 *int32, 返回项索引 *int32) bool {
	return xc.X列表视图_取选择项(l.X句柄, 返回组索引, 返回项索引)
}

// 列表视_添加选择项.
//
// iGroup: 组索引.
//
// iItem: 项索引.
func (l *X结构_列表视图) X添加选择项(组索引 int32, 项索引 int32) bool {
	return xc.X列表视图_添加选择项(l.X句柄, 组索引, 项索引)
}

// 列表视_显示指定项.
//
// iGroup: 组索引.
//
// iItem: 项索引.
func (l *X结构_列表视图) X显示指定项(组索引 int32, 项索引 int32) *X结构_列表视图 {
	xc.X列表视图_显示指定项(l.X句柄, 组索引, 项索引)
	return l
}

// 列表视_取可视项范围, 获取当前可见项范围.
//
// piGroup1: 可视开始组.
//
// piGroup2: 可视结束组.
//
// piStartGroup: 可视开始组.
//
// piStartItem: 可视开始项.
//
// piEndGroup: 可视结束组.
//
// piEndItem: 可视结束项.
func (l *X结构_列表视图) X取可视项范围(组1 *int32, 组2 *int32, 可视开始组 *int32, 可视开始项 *int32, 可视结束组 *int32, 可视结束项 *int32) *X结构_列表视图 {
	xc.X列表视图_取可视项范围(l.X句柄, 组1, 组2, 可视开始组, 可视开始项, 可视结束组, 可视结束项)
	return l
}

// 列表视_取选择项数量.
func (l *X结构_列表视图) X取选择项数量() int32 {
	return xc.X列表视图_取选择项数量(l.X句柄)
}

// 列表视_取选择项全部, 获取选择的项ID, 返回接收项数量.
//
// pArray: 数组.
//
// nArraySize: 数组大小.
func (l *X结构_列表视图) X取选择项全部(数组 *[]xc.X结构_列表视图项ID, nArraySize int32) int32 {
	return xc.X列表视图_取选择项全部(l.X句柄, 数组, nArraySize)
}

// 列表视_置选择项全部, 选择所有的项.
func (l *X结构_列表视图) X设置选择项全部() *X结构_列表视图 {
	xc.X列表视图_设置选择项全部(l.X句柄)
	return l
}

// 列表视_取消选择项全部, 取消选择所有项.
func (l *X结构_列表视图) X取消选择项全部() *X结构_列表视图 {
	xc.X列表视图_取消选择项全部(l.X句柄)
	return l
}

// 列表视_置列间隔, 置列间隔大小.
//
// space: 间隔大小.
func (l *X结构_列表视图) X设置列间隔(间隔大小 int32) *X结构_列表视图 {
	xc.X列表视图_设置列间隔(l.X句柄, 间隔大小)
	return l
}

// 列表视_置行间隔, 置行间隔大小.
//
// space: 间隔大小.
func (l *X结构_列表视图) X设置行间隔(间隔大小 int32) *X结构_列表视图 {
	xc.X列表视图_设置行间隔(l.X句柄, 间隔大小)
	return l
}

// 列表视_置项大小.
//
// width: 宽度.
//
// height: 高度.
func (l *X结构_列表视图) X设置项大小(宽度 int32, 高度 int32) *X结构_列表视图 {
	xc.X列表视图_设置项大小(l.X句柄, 宽度, 高度)
	return l
}

// 列表视_取项大小.
//
// pSize: 接收返回大小.
func (l *X结构_列表视图) X取项大小(返回大小 *xc.X结构_大小) *X结构_列表视图 {
	xc.X列表视图_取项大小(l.X句柄, 返回大小)
	return l
}

// 列表视_置组高度.
//
// height: 高度.
func (l *X结构_列表视图) X设置组高度(高度 int32) *X结构_列表视图 {
	xc.X列表视图_设置组高度(l.X句柄, 高度)
	return l
}

// 列表视_取组高度.
func (l *X结构_列表视图) X取组高度() int32 {
	return xc.X列表视图_取组高度(l.X句柄)
}

// 列表视_置组用户数据.
//
// iGroup: 组索引.
//
// nData: 数据.
func (l *X结构_列表视图) X设置组用户数据(组索引 int32, 数据 int) *X结构_列表视图 {
	xc.X列表视图_设置组用户数据(l.X句柄, 组索引, 数据)
	return l
}

// 列表视_置项用户数据.
//
// iGroup: 组索引.
//
// iItem: 项索引.
//
// nData: 数据.
func (l *X结构_列表视图) X设置项用户数据(组索引 int32, 项索引 int32, 数据 int) *X结构_列表视图 {
	xc.X列表视图_设置项用户数据(l.X句柄, 组索引, 项索引, 数据)
	return l
}

// 列表视_取组用户数据.
//
// iGroup: 组索引.
func (l *X结构_列表视图) X取组用户数据(组索引 int32) int {
	return xc.X列表视图_取组用户数据(l.X句柄, 组索引)
}

// 列表视_取项用户数据.
//
// iGroup: 组索引.
//
// iItem: 项索引.
func (l *X结构_列表视图) X取项用户数据(组索引 int32, 项索引 int32) int {
	return xc.X列表视图_取项用户数据(l.X句柄, 组索引, 项索引)
}

// 列表视_刷新项数据.
func (l *X结构_列表视图) X刷新项数据() *X结构_列表视图 {
	xc.X列表视图_刷新项数据(l.X句柄)
	return l
}

// 列表视_刷新指定项, 刷新指定项模板, 以便更新UI.
//
// iGroup: 组索引.
//
// iItem: 项索引, 如果为-1, 代表为组.
func (l *X结构_列表视图) X刷新指定项(组索引 int32, 项索引 int32) *X结构_列表视图 {
	xc.X列表视图_刷新指定项(l.X句柄, 组索引, 项索引)
	return l
}

// 列表视_展开组, 成功返回TRUE否则返回FALSE, 如果状态没有改变返回FALSE.
//
// iGroup: 组索引.
//
// bExpand: 是否展开.
func (l *X结构_列表视图) X展开组(组索引 int32, 是否展开 bool) bool {
	return xc.X列表视图_展开组(l.X句柄, 组索引, 是否展开)
}

// 列表视_组添加列, 返回列索引.
//
// pName: 字段称.
func (l *X结构_列表视图) X组添加列(字段名称 string) int32 {
	return xc.X列表视图_组添加列(l.X句柄, 字段名称)
}

// 列表视_组添加项文本, 返回组索引.
//
// pValue: 值.
//
// iPos: 插入位置.
func (l *X结构_列表视图) X组添加项文本(值 string, 插入位置 int32) int32 {
	return xc.X列表视图_组添加项文本(l.X句柄, 值, 插入位置)
}

// 列表视_组添加项文本扩展, 返回组索引.
//
// pName: 字段称.
//
// pValue: 值.
//
// iPos: 插入位置.
func (l *X结构_列表视图) X组添加项文本EX(字段名称 string, 值 string, 插入位置 int32) int32 {
	return xc.X列表视图_组添加项文本EX(l.X句柄, 字段名称, 值, 插入位置)
}

// 列表视_组添加项图片, 返回组索引.
//
// hImage: 图片句柄.
//
// iPos: 插入位置.
func (l *X结构_列表视图) X组添加项图片(图片句柄 int, 插入位置 int32) int32 {
	return xc.X列表视图_组添加项图片(l.X句柄, 图片句柄, 插入位置)
}

// 列表视_组添加项图片扩展, 返回组索引.
//
// pName: 字段称.
//
// hImage: 图片句柄.
//
// iPos: 插入位置.
func (l *X结构_列表视图) X组添加项图片EX(字段名称 string, 图片句柄 int, 插入位置 int32) int32 {
	return xc.X列表视图_组添加项图片EX(l.X句柄, 字段名称, 图片句柄, 插入位置)
}

// 列表视_组置文本.
//
// iGroup: 组索引.
//
// iColumn: 列索引.
//
// pValue: 值.
func (l *X结构_列表视图) X组置文本(组索引 int32, 列索引 int32, 值 string) bool {
	return xc.X列表视图_组置文本(l.X句柄, 组索引, 列索引, 值)
}

// 列表视_组置文本扩展.
//
// iGroup: 组索引.
//
// pName: 字段名.
//
// pValue: 值.
func (l *X结构_列表视图) X组置文本EX(组索引 int32, 字段名 string, 值 string) bool {
	return xc.X列表视图_组置文本EX(l.X句柄, 组索引, 字段名, 值)
}

// 列表视_组置图片.
//
// iGroup: 组索引.
//
// iColumn: 列索引.
//
// hImage: 图片句柄.
func (l *X结构_列表视图) X组置图片(组索引 int32, 列索引 int32, 图片句柄 int) bool {
	return xc.X列表视图_组置图片(l.X句柄, 组索引, 列索引, 图片句柄)
}

// 列表视_组置图片扩展.
//
// iGroup: 组索引.
//
// pName: 字段名.
//
// hImage: 图片句柄.
func (l *X结构_列表视图) X组置图片EX(组索引 int32, 字段名 string, 图片句柄 int) bool {
	return xc.X列表视图_组置图片EX(l.X句柄, 组索引, 字段名, 图片句柄)
}

// 列表视_组获取数量, 返回组数量.
func (l *X结构_列表视图) X组获取数量() int32 {
	return xc.X列表视图_组获取数量(l.X句柄)
}

// 列表视_项获取数量, 成功返回项数量, 否则返回 XC_ID_ERROR.
//
// iGroup: 组索引.
func (l *X结构_列表视图) X项获取数量(组索引 int32) int32 {
	return xc.X列表视图_项获取数量(l.X句柄, 组索引)
}

// 列表视_项添加列, 返回列索引.
//
// pName: 字段名.
func (l *X结构_列表视图) X项添加列(字段名 string) int32 {
	return xc.X列表视图_项添加列(l.X句柄, 字段名)
}

// 列表视_项添加文本, 返回项索引.
//
// iGroup: 组索引.
//
// pValue: 值.
//
// iPos: 插入位置, -1添加到末尾.
func (l *X结构_列表视图) X项添加文本(组索引 int32, 值 string, 插入位置 int32) int32 {
	return xc.X列表视图_项添加文本(l.X句柄, 组索引, 值, 插入位置)
}

// 列表视_项添加文本扩展, 返回项索引.
//
// iGroup: 组索引.
//
// pName: 字段名.
//
// pValue: 值.
//
// iPos: 插入位置, -1添加到末尾.
func (l *X结构_列表视图) X项添加文本EX(组索引 int32, 字段名 string, 值 string, 插入位置 int32) int32 {
	return xc.X列表视图_项添加文本EX(l.X句柄, 组索引, 字段名, 值, 插入位置)
}

// 列表视_项添加图片, 返回项索引.
//
// iGroup: 组索引.
//
// hImage: 图片句柄.
//
// iPos: 插入位置, -1添加到末尾.
func (l *X结构_列表视图) X项添加图片(组索引 int32, 图片句柄 int, 插入位置 int32) int32 {
	return xc.X列表视图_项添加图片(l.X句柄, 组索引, 图片句柄, 插入位置)
}

// 列表视_项添加图片扩展, 返回项索引.
//
// iGroup: 组索引.
//
// pName: 字段名.
//
// hImage: 图片句柄.
//
// iPos: 插入位置, -1添加到末尾.
func (l *X结构_列表视图) X项添加图片EX(组索引 int32, 字段名 string, 图片句柄 int, 插入位置 int32) int32 {
	return xc.X列表视图_项添加图片EX(l.X句柄, 组索引, 字段名, 图片句柄, 插入位置)
}

// 列表视_项置文本.
//
// iGroup: 组索引.
//
// iItem: 项索引.
//
// iColumn: 列索引.
//
// pValue: 值.
func (l *X结构_列表视图) X项置文本(组索引 int32, 项索引 int32, 列索引 int32, 值 string) bool {
	return xc.X列表视图_项置文本(l.X句柄, 组索引, 项索引, 列索引, 值)
}

// 列表视_项置文本扩展.
//
// iGroup: 组索引.
//
// iItem: 项索引.
//
// pName: 字段名.
//
// pValue: 值.
func (l *X结构_列表视图) X项置文本EX(组索引 int32, 项索引 int32, 字段名 string, 值 string) bool {
	return xc.X列表视图_项置文本EX(l.X句柄, 组索引, 项索引, 字段名, 值)
}

// 列表视_项置图片.
//
// iGroup: 组索引.
//
// iItem: 项索引.
//
// iColumn: 列索引.
//
// hImage: 图片句柄.
func (l *X结构_列表视图) X项置图片(组索引 int32, 项索引 int32, 列索引 int32, 图片句柄 int) bool {
	return xc.X列表视图_项置图片(l.X句柄, 组索引, 项索引, 列索引, 图片句柄)
}

// 列表视_项置图片扩展.
//
// iGroup: 组索引.
//
// iItem: 项索引.
//
// pName: 列名称.
//
// hImage: 图片句柄.
func (l *X结构_列表视图) X项置图片EX(组索引 int32, 项索引 int32, 列名称 string, 图片句柄 int) bool {
	return xc.X列表视图_项置图片EX(l.X句柄, 组索引, 项索引, 列名称, 图片句柄)
}

// 列表视_组删除项.
//
// iGroup: 组索引.
func (l *X结构_列表视图) X组删除项(组索引 int32) bool {
	return xc.X列表视图_组删除项(l.X句柄, 组索引)
}

// 列表视_组删除全部子项.
//
// iGroup: 组索引.
func (l *X结构_列表视图) X组删除全部子项(组索引 int32) *X结构_列表视图 {
	xc.X列表视图_组删除全部子项(l.X句柄, 组索引)
	return l
}

// 列表视_项删除.
//
// iGroup: 组索引.
//
// iItem: 项索引.
func (l *X结构_列表视图) X项删除(组索引 int32, 项索引 int32) bool {
	return xc.X列表视图_项删除(l.X句柄, 组索引, 项索引)
}

// 列表视_删除全部.
func (l *X结构_列表视图) X删除全部() *X结构_列表视图 {
	xc.X列表视图_删除全部(l.X句柄)
	return l
}

// 列表视_删除全部组.
func (l *X结构_列表视图) X删除全部组() *X结构_列表视图 {
	xc.X列表视图_删除全部组(l.X句柄)
	return l
}

// 列表视_删除全部项.
func (l *X结构_列表视图) X删除全部项() *X结构_列表视图 {
	xc.X列表视图_删除全部项(l.X句柄)
	return l
}

// 列表视_组删除列.
//
// iColumn: 列索引.
func (l *X结构_列表视图) X组删除列(列索引 int32) *X结构_列表视图 {
	xc.X列表视图_组删除列(l.X句柄, 列索引)
	return l
}

// 列表视_项删除列.
//
// iColumn: 列索引.
func (l *X结构_列表视图) X项删除列(列索引 int32) *X结构_列表视图 {
	xc.X列表视图_项删除列(l.X句柄, 列索引)
	return l
}

// 列表视_项获取文本.
//
// iGroup: 组索引.
//
// iItem: 项索引.
//
// pName: 字段称.
func (l *X结构_列表视图) X项获取文本(组索引 int32, 项索引 int32, 字段名称 string) string {
	return xc.X列表视图_项获取文本(l.X句柄, 组索引, 项索引, 字段名称)
}

// 列表视_项获取图片扩展, 返回图片句柄.
//
// iGroup: 组索引.
//
// iItem: 项索引.
//
// pName: 字段称.
func (l *X结构_列表视图) X项获取图片EX(组索引 int32, 项索引 int32, 字段名称 string) int {
	return xc.X列表视图_项获取图片EX(l.X句柄, 组索引, 项索引, 字段名称)
}

// 列表视_组取文本, 返回文本内容.
//
// iGroup: 组索引.
//
// iColumn: 列索引.
func (l *X结构_列表视图) X组取文本(组索引 int32, 列索引 int32) string {
	return xc.X列表视图_组取文本(l.X句柄, 组索引, 列索引)
}

// 列表视_组取文本扩展, 返回文本内容.
//
// iGroup: 组索引.
//
// pName: 字段名称.
func (l *X结构_列表视图) X组取文本EX(组索引 int32, 字段名称 string) string {
	return xc.X列表视图_组取文本EX(l.X句柄, 组索引, 字段名称)
}

// 列表视_组取图片, 返回图片句柄.
//
// iGroup: 组索引.
//
// iColumn: 列索引.
func (l *X结构_列表视图) X组取图片(组索引 int32, 列索引 int32) int {
	return xc.X列表视图_组取图片(l.X句柄, 组索引, 列索引)
}

// 列表视_组取图片扩展, 返回图片句柄.
//
// iGroup: 组索引.
//
// pName: 字段名称.
func (l *X结构_列表视图) X组取图片EX(组索引 int32, 字段名称 string) int {
	return xc.X列表视图_组取图片EX(l.X句柄, 组索引, 字段名称)
}

// 列表视_项取文本, 返回文本内容.
//
// iGroup: 组索引.
//
// iItem: 项索引.
//
// iColumn: 列索引.
func (l *X结构_列表视图) X项取文本(组索引 int32, 项索引 int32, 列索引 int32) string {
	return xc.X列表视图_项取文本(l.X句柄, 组索引, 项索引, 列索引)
}

// 列表视_项取图片, 返回图片句柄.
//
// iGroup: 组索引.
//
// iItem: 项索引.
//
// iColumn: 列索引.
func (l *X结构_列表视图) X项取图片(组索引 int32, 项索引 int32, 列索引 int32) int {
	return xc.X列表视图_项取图片(l.X句柄, 组索引, 项索引, 列索引)
}

// 列表视_置拖动矩形颜色.
//
// color: xc.RGBA 颜色.
//
// width: 线宽度.
func (l *X结构_列表视图) X设置拖动矩形颜色(ABGR颜色 int, 线宽度 int32) *X结构_列表视图 {
	xc.X列表视图_设置拖动矩形颜色(l.X句柄, ABGR颜色, 线宽度)
	return l
}

// 列表视_置项模板从内存.
//
// data: 模板数据.
func (l *X结构_列表视图) X设置项模板并按内存(模板数据 []byte) bool {
	return xc.X列表视图_设置项模板从内存(l.X句柄, 模板数据)
}

// 列表视_置项模板从资源ZIP.
//
// id: RC资源ID.
//
// pFileName: 文件名.
//
// pPassword: zip密码.
//
// hModule: 模块句柄, 可填0.
func (l *X结构_列表视图) X设置项模板并按资源zip(RC资源ID int32, 文件名 string, zip密码 string, 模块句柄 uintptr) bool {
	return xc.X列表视图_设置项模板从资源zip(l.X句柄, RC资源ID, 文件名, zip密码, 模块句柄)
}

// 列表视_取项模板, 返回项模板句柄.
func (l *X结构_列表视图) X取项模板() int {
	return xc.X列表视图_取项模板(l.X句柄)
}

// 列表视_取项模板组, 返回项模板组句柄.
func (l *X结构_列表视图) X取项模板组() int {
	return xc.X列表视图_取项模板组(l.X句柄)
}

// ------------------------- 事件 ------------------------- //

// 列表视元素-项模板创建事件,模板复用机制需先启用; 替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变(当前未使用); 1新模板实例; 2旧模板复用
type X事件_列表视图_项模板创建 func(pItem *xc.X结构_列表视图项, nFlag int32, pbHandled *bool) int

// 列表视元素-项模板创建事件,模板复用机制需先启用; 替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变(当前未使用); 1新模板实例; 2旧模板复用
type X事件_列表视图_项模板创建1 func(hEle int, pItem *xc.X结构_列表视图项, nFlag int32, pbHandled *bool) int

// 列表视元素-项模板创建完成事件,模板复用机制需先启用; 不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用,当前未使用); 1:新模板实例; 2:旧模板复用
type X事件_列表视图_项模板创建完成 func(pItem *xc.X结构_列表视图项, nFlag int32, pbHandled *bool) int

// 列表视元素-项模板创建完成事件,模板复用机制需先启用; 不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用,当前未使用); 1:新模板实例; 2:旧模板复用
type X事件_列表视图_项模板创建完成1 func(hEle int, pItem *xc.X结构_列表视图项, nFlag int32, pbHandled *bool) int

// 列表视元素-项模板销毁, 模板复用机制需先启用;
//
// nFlag   0:正常销毁;  1:移动到缓存列表(不会被销毁, 临时缓存备用, 当需要时被复用)
type X事件_列表视图_项模板销毁 func(pItem *xc.X结构_列表视图项, nFlag int32, pbHandled *bool) int

// 列表视元素-项模板销毁, 模板复用机制需先启用;
//
// nFlag   0:正常销毁;  1:移动到缓存列表(不会被销毁, 临时缓存备用, 当需要时被复用)
type X事件_列表视图_项模板销毁1 func(hEle int, pItem *xc.X结构_列表视图项, nFlag int32, pbHandled *bool) int
type X事件_列表视图_项模板调整坐标 func(pItem *xc.X结构_列表视图项, pbHandled *bool) int            // 列表视元素,项模板调整坐标.已停用.
type X事件_列表视图_项模板调整坐标1 func(hEle int, pItem *xc.X结构_列表视图项, pbHandled *bool) int // 列表视元素,项模板调整坐标.已停用.
type X事件_列表视图_自绘项 func(hDraw int, pItem *xc.X结构_列表视图项, pbHandled *bool) int               // 列表视元素,自绘项.
type X事件_列表视图_自绘项1 func(hEle int, hDraw int, pItem *xc.X结构_列表视图项, pbHandled *bool) int    // 列表视元素,自绘项.
type X事件_列表视图_项选择 func(iGroup int32, iItem int32, pbHandled *bool) int                           // 列表视元素,项选择事件.
type X事件_列表视图_项选择1 func(hEle int, iGroup int32, iItem int32, pbHandled *bool) int                // 列表视元素,项选择事件.
type X事件_列表视图_组展开收缩 func(iGroup int32, bExpand bool, pbHandled *bool) int                          // 列表视元素,组展开收缩事件.
type X事件_列表视图_组展开收缩1 func(hEle int, iGroup int32, bExpand bool, pbHandled *bool) int               // 列表视元素,组展开收缩事件.

// 列表视元素-项模板创建事件,模板复用机制需先启用; 替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变(当前未使用); 1新模板实例; 2旧模板复用
func (l *X结构_列表视图) X事件_项模板创建(回调函数 X事件_列表视图_项模板创建) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表视图_项模板创建, 回调函数)
}

// 列表视元素-项模板创建事件,模板复用机制需先启用; 替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变(当前未使用); 1新模板实例; 2旧模板复用
func (l *X结构_列表视图) X事件_项模板创建1(回调函数 X事件_列表视图_项模板创建1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表视图_项模板创建, 回调函数)
}

// 列表视元素-项模板创建完成事件,模板复用机制需先启用; 不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用,当前未使用); 1:新模板实例; 2:旧模板复用
func (l *X结构_列表视图) X事件_项模板创建完成(回调函数 X事件_列表视图_项模板创建完成) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表视图_项模板创建完成, 回调函数)
}

// 列表视元素-项模板创建完成事件,模板复用机制需先启用; 不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用,当前未使用); 1:新模板实例; 2:旧模板复用
func (l *X结构_列表视图) X事件_项模板创建完成1(回调函数 X事件_列表视图_项模板创建完成1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表视图_项模板创建完成, 回调函数)
}

// 列表视元素-项模板销毁, 模板复用机制需先启用;
//
// nFlag   0:正常销毁;  1:移动到缓存列表(不会被销毁, 临时缓存备用, 当需要时被复用)
func (l *X结构_列表视图) X事件_项模板销毁(回调函数 X事件_列表视图_项模板销毁) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表视图_项模板销毁, 回调函数)
}

// 列表视元素-项模板销毁, 模板复用机制需先启用;
//
// nFlag   0:正常销毁;  1:移动到缓存列表(不会被销毁, 临时缓存备用, 当需要时被复用)
func (l *X结构_列表视图) X事件_项模板销毁1(回调函数 X事件_列表视图_项模板销毁1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表视图_项模板销毁, 回调函数)
}

// 列表视元素,项模板调整坐标.已停用.
func (l *X结构_列表视图) X事件_项模板调整坐标(回调函数 X事件_列表视图_项模板调整坐标) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表视图_项模板调整坐标_已停用, 回调函数)
}

// 列表视元素,项模板调整坐标.已停用.
func (l *X结构_列表视图) X事件_项模板调整坐标1(回调函数 X事件_列表视图_项模板调整坐标1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表视图_项模板调整坐标_已停用, 回调函数)
}

// 列表视元素,自绘项.
func (l *X结构_列表视图) X事件_自绘项(回调函数 X事件_列表视图_自绘项) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表视图_自绘项, 回调函数)
}

// 列表视元素,自绘项.
func (l *X结构_列表视图) X事件_自绘项1(回调函数 X事件_列表视图_自绘项1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表视图_自绘项, 回调函数)
}

// 列表视元素,项选择事件.
func (l *X结构_列表视图) X事件_项选择(回调函数 X事件_列表视图_项选择) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表视图_项选择事件, 回调函数)
}

// 列表视元素,项选择事件.
func (l *X结构_列表视图) X事件_项选择1(回调函数 X事件_列表视图_项选择1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表视图_项选择事件, 回调函数)
}

// 列表视元素,组展开收缩事件.
func (l *X结构_列表视图) X事件_组展开收缩(回调函数 X事件_列表视图_组展开收缩) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表视图_组展开收缩, 回调函数)
}

// 列表视元素,组展开收缩事件.
func (l *X结构_列表视图) X事件_组展开收缩1(回调函数 X事件_列表视图_组展开收缩1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表视图_组展开收缩, 回调函数)
}

// ------------------------- AddEvent ------------------------- //

// AddEvent_ListView_Temp_Create 添加列表视元素-项模板创建事件, 模板复用机制需先启用. 替换模板无效判断nFlag, 因为内部会检查模板是否改变, 不用担心重复.
//   - nFlag: 0: 状态改变(当前未使用); 1: 新模板实例; 2: 旧模板复用
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表视图) AddEvent_ListView_Temp_Create(pFun X事件_列表视图_项模板创建1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表视图_项模板创建, onXE_LISTVIEW_TEMP_CREATE, pFun, allowAddingMultiple...)
}

// onXE_LISTVIEW_TEMP_CREATE 列表视元素-项模板创建事件, 模板复用机制需先启用.
func onXE_LISTVIEW_TEMP_CREATE(hEle int, pItem *xc.X结构_列表视图项, nFlag int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表视图_项模板创建)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表视图_项模板创建1)(hEle, pItem, nFlag, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_ListView_Temp_Create_End 添加列表视元素-项模板创建完成事件, 模板复用机制需先启用. 不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//   - nFlag: 0: 状态改变(复用,当前未使用); 1: 新模板实例; 2: 旧模板复用
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表视图) AddEvent_ListView_Temp_Create_End(pFun X事件_列表视图_项模板创建完成1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表视图_项模板创建完成, onXE_LISTVIEW_TEMP_CREATE_END, pFun, allowAddingMultiple...)
}

// onXE_LISTVIEW_TEMP_CREATE_END 列表视元素-项模板创建完成事件, 模板复用机制需先启用.
func onXE_LISTVIEW_TEMP_CREATE_END(hEle int, pItem *xc.X结构_列表视图项, nFlag int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表视图_项模板创建完成)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表视图_项模板创建完成1)(hEle, pItem, nFlag, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_ListView_Temp_Destroy 添加列表视元素-项模板销毁事件, 模板复用机制需先启用.
//   - nFlag: 0: 正常销毁; 1: 移动到缓存列表(不会被销毁, 临时缓存备用, 当需要时被复用)
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表视图) AddEvent_ListView_Temp_Destroy(pFun X事件_列表视图_项模板销毁1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表视图_项模板销毁, onXE_LISTVIEW_TEMP_DESTROY, pFun, allowAddingMultiple...)
}

// onXE_LISTVIEW_TEMP_DESTROY 列表视元素-项模板销毁事件, 模板复用机制需先启用.
func onXE_LISTVIEW_TEMP_DESTROY(hEle int, pItem *xc.X结构_列表视图项, nFlag int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表视图_项模板销毁)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表视图_项模板销毁1)(hEle, pItem, nFlag, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_ListView_Temp_Adjust_Coordinate 添加列表视元素-项模板调整坐标事件. 已停用.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表视图) AddEvent_ListView_Temp_Adjust_Coordinate(pFun X事件_列表视图_项模板调整坐标1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表视图_项模板调整坐标_已停用, onXE_LISTVIEW_TEMP_ADJUST_COORDINATE, pFun, allowAddingMultiple...)
}

// onXE_LISTVIEW_TEMP_ADJUST_COORDINATE 列表视元素-项模板调整坐标事件.已停用.
func onXE_LISTVIEW_TEMP_ADJUST_COORDINATE(hEle int, pItem *xc.X结构_列表视图项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表视图_项模板调整坐标_已停用)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表视图_项模板调整坐标1)(hEle, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_ListView_DrawItem 添加列表视元素-自绘项事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表视图) AddEvent_ListView_DrawItem(pFun X事件_列表视图_自绘项1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表视图_自绘项, onXE_LISTVIEW_DRAWITEM, pFun, allowAddingMultiple...)
}

// onXE_LISTVIEW_DRAWITEM 列表视元素-自绘项事件.
func onXE_LISTVIEW_DRAWITEM(hEle int, hDraw int, pItem *xc.X结构_列表视图项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表视图_自绘项)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表视图_自绘项1)(hEle, hDraw, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_ListView_Select 添加列表视元素-项选择事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表视图) AddEvent_ListView_Select(pFun X事件_列表视图_项选择1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表视图_项选择事件, onXE_LISTVIEW_SELECT, pFun, allowAddingMultiple...)
}

// onXE_LISTVIEW_SELECT 列表视元素-项选择事件.
func onXE_LISTVIEW_SELECT(hEle int, iGroup int32, iItem int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表视图_项选择事件)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表视图_项选择1)(hEle, iGroup, iItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_ListView_Expand 添加列表视元素-组展开收缩事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表视图) AddEvent_ListView_Expand(pFun X事件_列表视图_组展开收缩1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表视图_组展开收缩, onXE_LISTVIEW_EXPAND, pFun, allowAddingMultiple...)
}

// onXE_LISTVIEW_EXPAND 列表视元素-组展开收缩事件.
func onXE_LISTVIEW_EXPAND(hEle int, iGroup int32, bExpand bool, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表视图_组展开收缩)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表视图_组展开收缩1)(hEle, iGroup, bExpand, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}
